<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE GADTs #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE FlexibleContexts #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE ScopedTypeVariables #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# OPTIONS_GHC -fspec-constr -fspec-constr-count=8 #-}</span><span>
</span><span id="line-5"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-7"></span><span class="hs-comment">-- Module      :  Distribution.Compat.CharParsing</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Copyright   :  (c) Edward Kmett 2011</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- License     :  BSD3</span><span>
</span><span id="line-10"></span><span class="hs-comment">--</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Maintainer  :  ekmett@gmail.com</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Stability   :  experimental</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- Portability :  non-portable</span><span>
</span><span id="line-14"></span><span class="hs-comment">--</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- Parsers for character streams</span><span>
</span><span id="line-16"></span><span class="hs-comment">--</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- Originally in @parsers@ package.</span><span>
</span><span id="line-18"></span><span class="hs-comment">--</span><span>
</span><span id="line-19"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-20"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Distribution.Compat.CharParsing</span><span>
</span><span id="line-21"></span><span>  </span><span class="hs-special">(</span><span>
</span><span id="line-22"></span><span>  </span><span class="annot"><span class="hs-comment">-- * Combinators</span></span><span>
</span><span id="line-23"></span><span>    </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#oneOf"><span class="hs-identifier">oneOf</span></a></span><span>        </span><span class="hs-comment">-- :: CharParsing m =&gt; [Char] -&gt; m Char</span><span>
</span><span id="line-24"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#noneOf"><span class="hs-identifier">noneOf</span></a></span><span>       </span><span class="hs-comment">-- :: CharParsing m =&gt; [Char] -&gt; m Char</span><span>
</span><span id="line-25"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier">spaces</span></a></span><span>       </span><span class="hs-comment">-- :: CharParsing m =&gt; m ()</span><span>
</span><span id="line-26"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-identifier">space</span></a></span><span>        </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-27"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#newline"><span class="hs-identifier">newline</span></a></span><span>      </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-28"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#tab"><span class="hs-identifier">tab</span></a></span><span>          </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-29"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#upper"><span class="hs-identifier">upper</span></a></span><span>        </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-30"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#lower"><span class="hs-identifier">lower</span></a></span><span>        </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-31"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#alphaNum"><span class="hs-identifier">alphaNum</span></a></span><span>     </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-32"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#letter"><span class="hs-identifier">letter</span></a></span><span>       </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-33"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#digit"><span class="hs-identifier">digit</span></a></span><span>        </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-34"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#hexDigit"><span class="hs-identifier">hexDigit</span></a></span><span>     </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-35"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#octDigit"><span class="hs-identifier">octDigit</span></a></span><span>     </span><span class="hs-comment">-- :: CharParsing m =&gt; m Char</span><span>
</span><span id="line-36"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfyRange"><span class="hs-identifier">satisfyRange</span></a></span><span> </span><span class="hs-comment">-- :: CharParsing m =&gt; Char -&gt; Char -&gt; m Char</span><span>
</span><span id="line-37"></span><span>  </span><span class="annot"><span class="hs-comment">-- * Class</span></span><span>
</span><span id="line-38"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier">CharParsing</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-39"></span><span>  </span><span class="annot"><span class="hs-comment">-- * Cabal additions</span></span><span>
</span><span id="line-40"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-identifier">integral</span></a></span><span>
</span><span id="line-41"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#signedIntegral"><span class="hs-identifier">signedIntegral</span></a></span><span>
</span><span id="line-42"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier">munch1</span></a></span><span>
</span><span id="line-43"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch"><span class="hs-identifier">munch</span></a></span><span>
</span><span id="line-44"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#skipSpaces1"><span class="hs-identifier">skipSpaces1</span></a></span><span>
</span><span id="line-45"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="hs-keyword">module</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html"><span class="hs-identifier">Distribution.Compat.Parsing</span></a></span><span>
</span><span id="line-46"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-47"></span><span>
</span><span id="line-48"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Compat.Prelude.html"><span class="hs-identifier">Distribution.Compat.Prelude</span></a></span><span>
</span><span id="line-50"></span><span>
</span><span id="line-51"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Class.html#"><span class="hs-identifier">Control.Monad.Trans.Class</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier">lift</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.State.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-53"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.State.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.Writer.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.Writer.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.RWS.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-57"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.RWS.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-58"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#"><span class="hs-identifier">Control.Monad.Trans.Reader</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier">ReaderT</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#"><span class="hs-identifier">Control.Monad.Trans.Identity</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier">IdentityT</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-60"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#"><span class="hs-identifier">Data.Char</span></a></span><span>
</span><span id="line-61"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../text/src/Data.Text.html#"><span class="hs-identifier">Data.Text</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../text/src/Data.Text.Internal.html#Text"><span class="hs-identifier">Text</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../text/src/Data.Text.Show.html#unpack"><span class="hs-identifier">unpack</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.html#"><span class="hs-identifier">Text.Parsec</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Parsec</span></span><span>
</span><span id="line-64"></span><span>
</span><span id="line-65"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html"><span class="hs-identifier">Distribution.Compat.Parsing</span></a></span><span>
</span><span id="line-66"></span><span>
</span><span id="line-67"></span><span class="hs-comment">-- | @oneOf cs@ succeeds if the current character is in the supplied</span><span>
</span><span id="line-68"></span><span class="hs-comment">-- list of characters @cs@. Returns the parsed character. See also</span><span>
</span><span id="line-69"></span><span class="hs-comment">-- 'satisfy'.</span><span>
</span><span id="line-70"></span><span class="hs-comment">--</span><span>
</span><span id="line-71"></span><span class="hs-comment">-- &gt;   vowel  = oneOf &quot;aeiou&quot;</span><span>
</span><span id="line-72"></span><span id="local-6989586621679627463"><span class="annot"><a href="Distribution.Compat.CharParsing.html#oneOf"><span class="hs-identifier hs-type">oneOf</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627463"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627463"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-73"></span><span id="oneOf"><span class="annot"><span class="annottext">oneOf :: forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#oneOf"><span class="hs-identifier hs-var hs-var">oneOf</span></a></span></span><span> </span><span id="local-6989586621679627270"><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627270"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679627268"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627268"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627268"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; [Char] -&gt; Bool
forall (t :: * -&gt; *) a. (Foldable t, Eq a) =&gt; a -&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#elem"><span class="hs-operator hs-var">`elem`</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627270"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-74"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#oneOf"><span class="hs-pragma hs-type">oneOf</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-75"></span><span>
</span><span id="line-76"></span><span class="hs-comment">-- | As the dual of 'oneOf', @noneOf cs@ succeeds if the current</span><span>
</span><span id="line-77"></span><span class="hs-comment">-- character is /not/ in the supplied list of characters @cs@. Returns the</span><span>
</span><span id="line-78"></span><span class="hs-comment">-- parsed character.</span><span>
</span><span id="line-79"></span><span class="hs-comment">--</span><span>
</span><span id="line-80"></span><span class="hs-comment">-- &gt;  consonant = noneOf &quot;aeiou&quot;</span><span>
</span><span id="line-81"></span><span id="local-6989586621679627266"><span class="annot"><a href="Distribution.Compat.CharParsing.html#noneOf"><span class="hs-identifier hs-type">noneOf</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-82"></span><span id="noneOf"><span class="annot"><span class="annottext">noneOf :: forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#noneOf"><span class="hs-identifier hs-var hs-var">noneOf</span></a></span></span><span> </span><span id="local-6989586621679627261"><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627261"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679627260"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627260"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627260"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; [Char] -&gt; Bool
forall (t :: * -&gt; *) a. (Foldable t, Eq a) =&gt; a -&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#notElem"><span class="hs-operator hs-var">`notElem`</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627261"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-83"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#noneOf"><span class="hs-pragma hs-type">noneOf</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-84"></span><span>
</span><span id="line-85"></span><span class="hs-comment">-- | Skips /zero/ or more white space characters. See also 'skipMany'.</span><span>
</span><span id="line-86"></span><span id="local-6989586621679627455"><span class="annot"><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-type">spaces</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627455"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627455"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-87"></span><span id="spaces"><span class="annot"><span class="annottext">spaces :: forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var hs-var">spaces</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-identifier hs-var">space</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; [Char] -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;white space&quot;</span></span><span>
</span><span id="line-88"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-pragma hs-type">spaces</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-89"></span><span>
</span><span id="line-90"></span><span class="hs-comment">-- | Parses a white space character (any character which satisfies 'isSpace')</span><span>
</span><span id="line-91"></span><span class="hs-comment">-- Returns the parsed character.</span><span>
</span><span id="line-92"></span><span id="local-6989586621679627450"><span class="annot"><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-identifier hs-type">space</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627450"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627450"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-93"></span><span id="space"><span class="annot"><span class="annottext">space :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-identifier hs-var hs-var">space</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isSpace"><span class="hs-identifier hs-var">isSpace</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;space&quot;</span></span><span>
</span><span id="line-94"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-pragma hs-type">space</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-95"></span><span>
</span><span id="line-96"></span><span class="hs-comment">-- | Parses a newline character (\'\\n\'). Returns a newline character.</span><span>
</span><span id="line-97"></span><span id="local-6989586621679627245"><span class="annot"><a href="Distribution.Compat.CharParsing.html#newline"><span class="hs-identifier hs-type">newline</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-98"></span><span id="newline"><span class="annot"><span class="annottext">newline :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#newline"><span class="hs-identifier hs-var hs-var">newline</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\n'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;new-line&quot;</span></span><span>
</span><span id="line-99"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#newline"><span class="hs-pragma hs-type">newline</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-100"></span><span>
</span><span id="line-101"></span><span class="hs-comment">-- | Parses a tab character (\'\\t\'). Returns a tab character.</span><span>
</span><span id="line-102"></span><span id="local-6989586621679627239"><span class="annot"><a href="Distribution.Compat.CharParsing.html#tab"><span class="hs-identifier hs-type">tab</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627239"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627239"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-103"></span><span id="tab"><span class="annot"><span class="annottext">tab :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#tab"><span class="hs-identifier hs-var hs-var">tab</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\t'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;tab&quot;</span></span><span>
</span><span id="line-104"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#tab"><span class="hs-pragma hs-type">tab</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-105"></span><span>
</span><span id="line-106"></span><span class="hs-comment">-- | Parses an upper case letter. Returns the parsed character.</span><span>
</span><span id="line-107"></span><span id="local-6989586621679627234"><span class="annot"><a href="Distribution.Compat.CharParsing.html#upper"><span class="hs-identifier hs-type">upper</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627234"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627234"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-108"></span><span id="upper"><span class="annot"><span class="annottext">upper :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#upper"><span class="hs-identifier hs-var hs-var">upper</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isUpper"><span class="hs-identifier hs-var">isUpper</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;uppercase letter&quot;</span></span><span>
</span><span id="line-109"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#upper"><span class="hs-pragma hs-type">upper</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-110"></span><span>
</span><span id="line-111"></span><span class="hs-comment">-- | Parses a lower case character. Returns the parsed character.</span><span>
</span><span id="line-112"></span><span id="local-6989586621679627228"><span class="annot"><a href="Distribution.Compat.CharParsing.html#lower"><span class="hs-identifier hs-type">lower</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627228"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627228"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-113"></span><span id="lower"><span class="annot"><span class="annottext">lower :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#lower"><span class="hs-identifier hs-var hs-var">lower</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isLower"><span class="hs-identifier hs-var">isLower</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;lowercase letter&quot;</span></span><span>
</span><span id="line-114"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#lower"><span class="hs-pragma hs-type">lower</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-115"></span><span>
</span><span id="line-116"></span><span class="hs-comment">-- | Parses a letter or digit. Returns the parsed character.</span><span>
</span><span id="line-117"></span><span id="local-6989586621679627222"><span class="annot"><a href="Distribution.Compat.CharParsing.html#alphaNum"><span class="hs-identifier hs-type">alphaNum</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-118"></span><span id="alphaNum"><span class="annot"><span class="annottext">alphaNum :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#alphaNum"><span class="hs-identifier hs-var hs-var">alphaNum</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlphaNum"><span class="hs-identifier hs-var">isAlphaNum</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;letter or digit&quot;</span></span><span>
</span><span id="line-119"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#alphaNum"><span class="hs-pragma hs-type">alphaNum</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-120"></span><span>
</span><span id="line-121"></span><span class="hs-comment">-- | Parses a letter (an upper case or lower case character). Returns the</span><span>
</span><span id="line-122"></span><span class="hs-comment">-- parsed character.</span><span>
</span><span id="line-123"></span><span id="local-6989586621679627216"><span class="annot"><a href="Distribution.Compat.CharParsing.html#letter"><span class="hs-identifier hs-type">letter</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627216"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627216"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-124"></span><span id="letter"><span class="annot"><span class="annottext">letter :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#letter"><span class="hs-identifier hs-var hs-var">letter</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlpha"><span class="hs-identifier hs-var">isAlpha</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;letter&quot;</span></span><span>
</span><span id="line-125"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#letter"><span class="hs-pragma hs-type">letter</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-126"></span><span>
</span><span id="line-127"></span><span class="hs-comment">-- | Parses a digit. Returns the parsed character.</span><span>
</span><span id="line-128"></span><span id="local-6989586621679627210"><span class="annot"><a href="Distribution.Compat.CharParsing.html#digit"><span class="hs-identifier hs-type">digit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627210"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627210"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-129"></span><span id="digit"><span class="annot"><span class="annottext">digit :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#digit"><span class="hs-identifier hs-var hs-var">digit</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isDigit"><span class="hs-identifier hs-var">isDigit</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;digit&quot;</span></span><span>
</span><span id="line-130"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#digit"><span class="hs-pragma hs-type">digit</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-131"></span><span>
</span><span id="line-132"></span><span class="hs-comment">-- | Parses a hexadecimal digit (a digit or a letter between \'a\' and</span><span>
</span><span id="line-133"></span><span class="hs-comment">-- \'f\' or \'A\' and \'F\'). Returns the parsed character.</span><span>
</span><span id="line-134"></span><span id="local-6989586621679627204"><span class="annot"><a href="Distribution.Compat.CharParsing.html#hexDigit"><span class="hs-identifier hs-type">hexDigit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627204"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627204"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-135"></span><span id="hexDigit"><span class="annot"><span class="annottext">hexDigit :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#hexDigit"><span class="hs-identifier hs-var hs-var">hexDigit</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isHexDigit"><span class="hs-identifier hs-var">isHexDigit</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;hexadecimal digit&quot;</span></span><span>
</span><span id="line-136"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#hexDigit"><span class="hs-pragma hs-type">hexDigit</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-137"></span><span>
</span><span id="line-138"></span><span class="hs-comment">-- | Parses an octal digit (a character between \'0\' and \'7\'). Returns</span><span>
</span><span id="line-139"></span><span class="hs-comment">-- the parsed character.</span><span>
</span><span id="line-140"></span><span id="local-6989586621679627198"><span class="annot"><a href="Distribution.Compat.CharParsing.html#octDigit"><span class="hs-identifier hs-type">octDigit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627198"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627198"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-141"></span><span id="octDigit"><span class="annot"><span class="annottext">octDigit :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#octDigit"><span class="hs-identifier hs-var hs-var">octDigit</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isOctDigit"><span class="hs-identifier hs-var">isOctDigit</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;octal digit&quot;</span></span><span>
</span><span id="line-142"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#octDigit"><span class="hs-pragma hs-type">octDigit</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-143"></span><span>
</span><span id="line-144"></span><span id="local-6989586621679627438"><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfyRange"><span class="hs-identifier hs-type">satisfyRange</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627438"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627438"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span>
</span><span id="line-145"></span><span id="satisfyRange"><span class="annot"><span class="annottext">satisfyRange :: forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfyRange"><span class="hs-identifier hs-var hs-var">satisfyRange</span></a></span></span><span> </span><span id="local-6989586621679627187"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627187"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679627186"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627186"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679627185"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627185"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627185"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627187"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627185"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627186"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-146"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfyRange"><span class="hs-pragma hs-type">satisfyRange</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span class="hs-comment">-- | Additional functionality needed to parse character streams.</span><span>
</span><span id="line-149"></span><span class="hs-keyword">class</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span id="CharParsing"><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-var">CharParsing</span></a></span></span><span> </span><span id="local-6989586621679627461"><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-150"></span><span>  </span><span class="hs-comment">-- | Parse a single character of the input, with UTF-8 decoding</span><span>
</span><span id="line-151"></span><span>  </span><span id="satisfy"><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-type">satisfy</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-152"></span><span>
</span><span id="line-153"></span><span>  </span><span class="hs-comment">-- | @char c@ parses a single character @c@. Returns the parsed</span><span>
</span><span id="line-154"></span><span>  </span><span class="hs-comment">-- character (i.e. @c@).</span><span>
</span><span id="line-155"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-156"></span><span>  </span><span class="hs-comment">-- /e.g./</span><span>
</span><span id="line-157"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-158"></span><span>  </span><span class="hs-comment">-- @semiColon = 'char' ';'@</span><span>
</span><span id="line-159"></span><span>  </span><span id="char"><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-type">char</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-160"></span><span>  </span><span id="local-6989586621679627181"><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var hs-var">char</span></a></span><span> </span><span id="local-6989586621679627172"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627172"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627172"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; [Char] -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; [Char]
forall a. Show a =&gt; a -&gt; [Char]
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627172"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-161"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-162"></span><span>
</span><span id="line-163"></span><span>  </span><span class="hs-comment">-- | @notChar c@ parses any single character other than @c@. Returns the parsed</span><span>
</span><span id="line-164"></span><span>  </span><span class="hs-comment">-- character.</span><span>
</span><span id="line-165"></span><span>  </span><span id="notChar"><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-type">notChar</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-166"></span><span>  </span><span id="local-6989586621679627169"><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var hs-var">notChar</span></a></span><span> </span><span id="local-6989586621679627166"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627166"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679627166"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-167"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-168"></span><span>
</span><span id="line-169"></span><span>  </span><span class="hs-comment">-- | This parser succeeds for any character. Returns the parsed character.</span><span>
</span><span id="line-170"></span><span>  </span><span id="anyChar"><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-type">anyChar</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-171"></span><span>  </span><span id="local-6989586621679627163"><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var hs-var">anyChar</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; Char -&gt; Bool
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-172"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-173"></span><span>
</span><span id="line-174"></span><span>  </span><span class="hs-comment">-- | @string s@ parses a sequence of characters given by @s@. Returns</span><span>
</span><span id="line-175"></span><span>  </span><span class="hs-comment">-- the parsed string (i.e. @s@).</span><span>
</span><span id="line-176"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-177"></span><span>  </span><span class="hs-comment">-- &gt;  divOrMod    =   string &quot;div&quot;</span><span>
</span><span id="line-178"></span><span>  </span><span class="hs-comment">-- &gt;              &lt;|&gt; string &quot;mod&quot;</span><span>
</span><span id="line-179"></span><span>  </span><span id="string"><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-type">string</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-180"></span><span>  </span><span id="local-6989586621679627159"><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var hs-var">string</span></a></span><span> </span><span id="local-6989586621679627143"><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627143"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627143"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m () -&gt; m [Char]
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; m Char) -&gt; [Char] -&gt; m ()
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Foldable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f ()
</span><a href="../../base/src/Data.Foldable.html#traverse_"><span class="hs-identifier hs-var">traverse_</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627143"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; [Char] -&gt; m [Char]
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; [Char]
forall a. Show a =&gt; a -&gt; [Char]
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="#local-6989586621679627143"><span class="hs-identifier hs-var">s</span></a></span></span><span>
</span><span id="line-181"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span>  </span><span class="hs-comment">-- | @text t@ parses a sequence of characters determined by the text @t@ Returns</span><span>
</span><span id="line-184"></span><span>  </span><span class="hs-comment">-- the parsed text fragment (i.e. @t@).</span><span>
</span><span id="line-185"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-186"></span><span>  </span><span class="hs-comment">-- Using @OverloadedStrings@:</span><span>
</span><span id="line-187"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-188"></span><span>  </span><span class="hs-comment">-- &gt;  divOrMod    =   text &quot;div&quot;</span><span>
</span><span id="line-189"></span><span>  </span><span class="hs-comment">-- &gt;              &lt;|&gt; text &quot;mod&quot;</span><span>
</span><span id="line-190"></span><span>  </span><span id="text"><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-type">text</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../text/src/Data.Text.Internal.html#Text"><span class="hs-identifier hs-type">Text</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../text/src/Data.Text.Internal.html#Text"><span class="hs-identifier hs-type">Text</span></a></span><span>
</span><span id="line-191"></span><span>  </span><span id="local-6989586621679627138"><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var hs-var">text</span></a></span><span> </span><span id="local-6989586621679627131"><span class="annot"><span class="annottext">Text
</span><a href="#local-6989586621679627131"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Text
</span><a href="#local-6989586621679627131"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m [Char] -&gt; m Text
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Text -&gt; [Char]
</span><a href="../../text/src/Data.Text.Show.html#unpack"><span class="hs-identifier hs-var">unpack</span></a></span><span> </span><span class="annot"><span class="annottext">Text
</span><a href="#local-6989586621679627131"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-192"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-193"></span><span>
</span><span id="line-194"></span><span id="local-6989586621679627410"><span id="local-6989586621679627411"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-type">Lazy.StateT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627410"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-195"></span><span>  </span><span id="local-6989586621679627110"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; StateT s m Char
</span><a href="#local-6989586621679627110"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-196"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-197"></span><span>  </span><span id="local-6989586621679627105"><span class="annot"><span class="annottext">char :: Char -&gt; StateT s m Char
</span><a href="#local-6989586621679627105"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-198"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-199"></span><span>  </span><span id="local-6989586621679627101"><span class="annot"><span class="annottext">notChar :: Char -&gt; StateT s m Char
</span><a href="#local-6989586621679627101"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-200"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-201"></span><span>  </span><span id="local-6989586621679627097"><span class="annot"><span class="annottext">anyChar :: StateT s m Char
</span><a href="#local-6989586621679627097"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-202"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-203"></span><span>  </span><span id="local-6989586621679627093"><span class="annot"><span class="annottext">string :: [Char] -&gt; StateT s m [Char]
</span><a href="#local-6989586621679627093"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; StateT s m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; StateT s m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; StateT s m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-204"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-205"></span><span>  </span><span id="local-6989586621679627089"><span class="annot"><span class="annottext">text :: Text -&gt; StateT s m Text
</span><a href="#local-6989586621679627089"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; StateT s m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; StateT s m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; StateT s m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-206"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span id="local-6989586621679627395"><span id="local-6989586621679627396"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627396"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627396"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">Strict.StateT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627395"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627396"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-209"></span><span>  </span><span id="local-6989586621679627070"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; StateT s m Char
</span><a href="#local-6989586621679627070"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-210"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-211"></span><span>  </span><span id="local-6989586621679627066"><span class="annot"><span class="annottext">char :: Char -&gt; StateT s m Char
</span><a href="#local-6989586621679627066"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-212"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-213"></span><span>  </span><span id="local-6989586621679627062"><span class="annot"><span class="annottext">notChar :: Char -&gt; StateT s m Char
</span><a href="#local-6989586621679627062"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; StateT s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; StateT s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-214"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-215"></span><span>  </span><span id="local-6989586621679627058"><span class="annot"><span class="annottext">anyChar :: StateT s m Char
</span><a href="#local-6989586621679627058"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; StateT s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-216"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-217"></span><span>  </span><span id="local-6989586621679627054"><span class="annot"><span class="annottext">string :: [Char] -&gt; StateT s m [Char]
</span><a href="#local-6989586621679627054"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; StateT s m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; StateT s m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; StateT s m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-218"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-219"></span><span>  </span><span id="local-6989586621679627050"><span class="annot"><span class="annottext">text :: Text -&gt; StateT s m Text
</span><a href="#local-6989586621679627050"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; StateT s m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; StateT s m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; StateT s m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-220"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-221"></span><span>
</span><span id="line-222"></span><span id="local-6989586621679627387"><span id="local-6989586621679627388"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627388"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627388"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627387"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627388"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-223"></span><span>  </span><span id="local-6989586621679627031"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; ReaderT e m Char
</span><a href="#local-6989586621679627031"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; ReaderT e m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; ReaderT e m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; ReaderT e m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-224"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-225"></span><span>  </span><span id="local-6989586621679627027"><span class="annot"><span class="annottext">char :: Char -&gt; ReaderT e m Char
</span><a href="#local-6989586621679627027"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; ReaderT e m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; ReaderT e m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; ReaderT e m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-226"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-227"></span><span>  </span><span id="local-6989586621679627023"><span class="annot"><span class="annottext">notChar :: Char -&gt; ReaderT e m Char
</span><a href="#local-6989586621679627023"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; ReaderT e m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; ReaderT e m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; ReaderT e m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-228"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-229"></span><span>  </span><span id="local-6989586621679627019"><span class="annot"><span class="annottext">anyChar :: ReaderT e m Char
</span><a href="#local-6989586621679627019"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; ReaderT e m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-230"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-231"></span><span>  </span><span id="local-6989586621679627015"><span class="annot"><span class="annottext">string :: [Char] -&gt; ReaderT e m [Char]
</span><a href="#local-6989586621679627015"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; ReaderT e m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; ReaderT e m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; ReaderT e m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-232"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-233"></span><span>  </span><span id="local-6989586621679627011"><span class="annot"><span class="annottext">text :: Text -&gt; ReaderT e m Text
</span><a href="#local-6989586621679627011"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; ReaderT e m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; ReaderT e m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; ReaderT e m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-234"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-235"></span><span>
</span><span id="line-236"></span><span id="local-6989586621679627379"><span id="local-6989586621679627380"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627380"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627380"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627379"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-type">Strict.WriterT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627379"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627380"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-237"></span><span>  </span><span id="local-6989586621679626991"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; WriterT w m Char
</span><a href="#local-6989586621679626991"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-238"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-239"></span><span>  </span><span id="local-6989586621679626987"><span class="annot"><span class="annottext">char :: Char -&gt; WriterT w m Char
</span><a href="#local-6989586621679626987"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-240"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-241"></span><span>  </span><span id="local-6989586621679626983"><span class="annot"><span class="annottext">notChar :: Char -&gt; WriterT w m Char
</span><a href="#local-6989586621679626983"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-242"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-243"></span><span>  </span><span id="local-6989586621679626979"><span class="annot"><span class="annottext">anyChar :: WriterT w m Char
</span><a href="#local-6989586621679626979"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-244"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-245"></span><span>  </span><span id="local-6989586621679626975"><span class="annot"><span class="annottext">string :: [Char] -&gt; WriterT w m [Char]
</span><a href="#local-6989586621679626975"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; WriterT w m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; WriterT w m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; WriterT w m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-246"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-247"></span><span>  </span><span id="local-6989586621679626971"><span class="annot"><span class="annottext">text :: Text -&gt; WriterT w m Text
</span><a href="#local-6989586621679626971"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; WriterT w m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; WriterT w m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; WriterT w m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-248"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-249"></span><span>
</span><span id="line-250"></span><span id="local-6989586621679627371"><span id="local-6989586621679627372"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627372"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627372"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627371"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-type">Lazy.WriterT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627371"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627372"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-251"></span><span>  </span><span id="local-6989586621679626951"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; WriterT w m Char
</span><a href="#local-6989586621679626951"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-252"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-253"></span><span>  </span><span id="local-6989586621679626947"><span class="annot"><span class="annottext">char :: Char -&gt; WriterT w m Char
</span><a href="#local-6989586621679626947"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-254"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-255"></span><span>  </span><span id="local-6989586621679626943"><span class="annot"><span class="annottext">notChar :: Char -&gt; WriterT w m Char
</span><a href="#local-6989586621679626943"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; WriterT w m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; WriterT w m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-256"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-257"></span><span>  </span><span id="local-6989586621679626939"><span class="annot"><span class="annottext">anyChar :: WriterT w m Char
</span><a href="#local-6989586621679626939"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; WriterT w m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-258"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-259"></span><span>  </span><span id="local-6989586621679626935"><span class="annot"><span class="annottext">string :: [Char] -&gt; WriterT w m [Char]
</span><a href="#local-6989586621679626935"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; WriterT w m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; WriterT w m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; WriterT w m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-260"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-261"></span><span>  </span><span id="local-6989586621679626931"><span class="annot"><span class="annottext">text :: Text -&gt; WriterT w m Text
</span><a href="#local-6989586621679626931"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; WriterT w m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; WriterT w m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; WriterT w m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-262"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-263"></span><span>
</span><span id="line-264"></span><span id="local-6989586621679627357"><span id="local-6989586621679627358"><span id="local-6989586621679627359"><span id="local-6989586621679627360"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627360"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627360"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627359"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-type">Lazy.RWST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627358"><span class="hs-identifier hs-type">r</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627359"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627357"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627360"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-265"></span><span>  </span><span id="local-6989586621679626911"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626911"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char)
-&gt; (Char -&gt; Bool)
-&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-266"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-267"></span><span>  </span><span id="local-6989586621679626907"><span class="annot"><span class="annottext">char :: Char -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626907"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-268"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-269"></span><span>  </span><span id="local-6989586621679626903"><span class="annot"><span class="annottext">notChar :: Char -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626903"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-270"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-271"></span><span>  </span><span id="local-6989586621679626899"><span class="annot"><span class="annottext">anyChar :: RWST r w s m Char
</span><a href="#local-6989586621679626899"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-272"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-273"></span><span>  </span><span id="local-6989586621679626895"><span class="annot"><span class="annottext">string :: [Char] -&gt; RWST r w s m [Char]
</span><a href="#local-6989586621679626895"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; RWST r w s m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; RWST r w s m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; RWST r w s m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-274"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-275"></span><span>  </span><span id="local-6989586621679626891"><span class="annot"><span class="annottext">text :: Text -&gt; RWST r w s m Text
</span><a href="#local-6989586621679626891"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; RWST r w s m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; RWST r w s m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; RWST r w s m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-276"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span></span></span><span>
</span><span id="line-277"></span><span>
</span><span id="line-278"></span><span id="local-6989586621679627341"><span id="local-6989586621679627342"><span id="local-6989586621679627343"><span id="local-6989586621679627344"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627344"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627344"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627343"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-type">Strict.RWST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627342"><span class="hs-identifier hs-type">r</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627343"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627341"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627344"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-279"></span><span>  </span><span id="local-6989586621679626871"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626871"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char)
-&gt; (Char -&gt; Bool)
-&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-280"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-281"></span><span>  </span><span id="local-6989586621679626867"><span class="annot"><span class="annottext">char :: Char -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626867"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-282"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-283"></span><span>  </span><span id="local-6989586621679626863"><span class="annot"><span class="annottext">notChar :: Char -&gt; RWST r w s m Char
</span><a href="#local-6989586621679626863"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; RWST r w s m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; RWST r w s m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-284"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-285"></span><span>  </span><span id="local-6989586621679626859"><span class="annot"><span class="annottext">anyChar :: RWST r w s m Char
</span><a href="#local-6989586621679626859"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; RWST r w s m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-286"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-287"></span><span>  </span><span id="local-6989586621679626855"><span class="annot"><span class="annottext">string :: [Char] -&gt; RWST r w s m [Char]
</span><a href="#local-6989586621679626855"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; RWST r w s m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; RWST r w s m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; RWST r w s m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-288"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-289"></span><span>  </span><span id="local-6989586621679626851"><span class="annot"><span class="annottext">text :: Text -&gt; RWST r w s m Text
</span><a href="#local-6989586621679626851"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; RWST r w s m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; RWST r w s m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; RWST r w s m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-290"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span></span></span><span>
</span><span id="line-291"></span><span>
</span><span id="line-292"></span><span id="local-6989586621679627334"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627334"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627334"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-type">IdentityT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627334"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-293"></span><span>  </span><span id="local-6989586621679626832"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; IdentityT m Char
</span><a href="#local-6989586621679626832"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; IdentityT m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; IdentityT m Char)
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; IdentityT m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-294"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-pragma hs-type">satisfy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-295"></span><span>  </span><span id="local-6989586621679626828"><span class="annot"><span class="annottext">char :: Char -&gt; IdentityT m Char
</span><a href="#local-6989586621679626828"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; IdentityT m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; IdentityT m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; IdentityT m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span>
</span><span id="line-296"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-pragma hs-type">char</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-297"></span><span>  </span><span id="local-6989586621679626824"><span class="annot"><span class="annottext">notChar :: Char -&gt; IdentityT m Char
</span><a href="#local-6989586621679626824"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; IdentityT m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; IdentityT m Char)
-&gt; (Char -&gt; m Char) -&gt; Char -&gt; IdentityT m Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">notChar</span></a></span><span>
</span><span id="line-298"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-pragma hs-type">notChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-299"></span><span>  </span><span id="local-6989586621679626820"><span class="annot"><span class="annottext">anyChar :: IdentityT m Char
</span><a href="#local-6989586621679626820"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; IdentityT m Char
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">anyChar</span></a></span><span>
</span><span id="line-300"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-pragma hs-type">anyChar</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-301"></span><span>  </span><span id="local-6989586621679626816"><span class="annot"><span class="annottext">string :: [Char] -&gt; IdentityT m [Char]
</span><a href="#local-6989586621679626816"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [Char] -&gt; IdentityT m [Char]
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m [Char] -&gt; IdentityT m [Char])
-&gt; ([Char] -&gt; m [Char]) -&gt; [Char] -&gt; IdentityT m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; m [Char]
forall (m :: * -&gt; *). CharParsing m =&gt; [Char] -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">string</span></a></span><span>
</span><span id="line-302"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-pragma hs-type">string</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-303"></span><span>  </span><span id="local-6989586621679626812"><span class="annot"><span class="annottext">text :: Text -&gt; IdentityT m Text
</span><a href="#local-6989586621679626812"><span class="hs-identifier hs-var hs-var hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Text -&gt; IdentityT m Text
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m Text -&gt; IdentityT m Text)
-&gt; (Text -&gt; m Text) -&gt; Text -&gt; IdentityT m Text
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Text -&gt; m Text
forall (m :: * -&gt; *). CharParsing m =&gt; Text -&gt; m Text
</span><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-identifier hs-var">text</span></a></span><span>
</span><span id="line-304"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#text"><span class="hs-pragma hs-type">text</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-305"></span><span>
</span><span id="line-306"></span><span id="local-6989586621679627327"><span id="local-6989586621679627328"><span id="local-6989586621679627329"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679626800"><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#Stream"><span class="hs-identifier hs-type">Parsec.Stream</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627329"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627328"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">Parsec.ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627329"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627327"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627328"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-307"></span><span>  </span><span id="local-6989586621679626798"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="#local-6989586621679626798"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="../../parsec/src/Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">Parsec.satisfy</span></a></span><span>
</span><span id="line-308"></span><span>  </span><span id="local-6989586621679626795"><span class="annot"><span class="annottext">char :: Char -&gt; ParsecT s u m Char
</span><a href="#local-6989586621679626795"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="../../parsec/src/Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">Parsec.char</span></a></span><span>
</span><span id="line-309"></span><span>  </span><span id="local-6989586621679626791"><span class="annot"><span class="annottext">notChar :: Char -&gt; ParsecT s u m Char
</span><a href="#local-6989586621679626791"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span> </span><span id="local-6989586621679626790"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679626790"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="../../parsec/src/Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">Parsec.satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679626790"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-310"></span><span>  </span><span id="local-6989586621679626788"><span class="annot"><span class="annottext">anyChar :: ParsecT s u m Char
</span><a href="#local-6989586621679626788"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="../../parsec/src/Text.Parsec.Char.html#anyChar"><span class="hs-identifier hs-var">Parsec.anyChar</span></a></span><span>
</span><span id="line-311"></span><span>  </span><span id="local-6989586621679626785"><span class="annot"><span class="annottext">string :: [Char] -&gt; ParsecT s u m [Char]
</span><a href="#local-6989586621679626785"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; ParsecT s u m [Char]
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
[Char] -&gt; ParsecT s u m [Char]
</span><a href="../../parsec/src/Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">Parsec.string</span></a></span></span></span></span><span>
</span><span id="line-312"></span><span>
</span><span id="line-313"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-314"></span><span class="hs-comment">-- Our additions</span><span>
</span><span id="line-315"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-316"></span><span>
</span><span id="line-317"></span><span id="local-6989586621679627325"><span id="local-6989586621679627326"><span class="annot"><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-identifier hs-type">integral</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627326"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627325"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627326"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627325"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-318"></span><span id="integral"><span class="annot"><span class="annottext">integral :: forall (m :: * -&gt; *) a. (CharParsing m, Integral a) =&gt; m a
</span><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-identifier hs-var hs-var">integral</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; a
</span><a href="#local-6989586621679626770"><span class="hs-identifier hs-var">toNumber</span></a></span><span> </span><span class="annot"><span class="annottext">([a] -&gt; a) -&gt; m [a] -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier hs-var">some</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679626767"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; [Char] -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; [Char] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;integral&quot;</span></span><span>
</span><span id="line-319"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-320"></span><span>    </span><span id="local-6989586621679626770"><span class="annot"><span class="annottext">toNumber :: [a] -&gt; a
</span><a href="#local-6989586621679626770"><span class="hs-identifier hs-var hs-var">toNumber</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; a) -&gt; a -&gt; [a] -&gt; a
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679626760"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679626760"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679626759"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679626759"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679626760"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679626759"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span>
</span><span id="line-321"></span><span>    </span><span id="local-6989586621679626767"><span class="annot"><span class="annottext">d :: m a
</span><a href="#local-6989586621679626767"><span class="hs-identifier hs-var hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; a
forall {p}. Num p =&gt; Char -&gt; p
</span><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; a) -&gt; m Char -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfyRange"><span class="hs-identifier hs-var">satisfyRange</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'0'</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'9'</span></span><span>
</span><span id="line-322"></span><span>    </span><span id="local-6989586621679626753"><span class="annot"><span class="annottext">f :: Char -&gt; p
</span><a href="#local-6989586621679626753"><span class="hs-identifier hs-var hs-var">f</span></a></span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'0'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">0</span></span><span>
</span><span id="line-323"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'1'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">1</span></span><span>
</span><span id="line-324"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'2'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">2</span></span><span>
</span><span id="line-325"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'3'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">3</span></span><span>
</span><span id="line-326"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'4'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">4</span></span><span>
</span><span id="line-327"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'5'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">5</span></span><span>
</span><span id="line-328"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'6'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">6</span></span><span>
</span><span id="line-329"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'7'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">7</span></span><span>
</span><span id="line-330"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'8'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">8</span></span><span>
</span><span id="line-331"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'9'</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">9</span></span><span>
</span><span id="line-332"></span><span>    </span><span class="annot"><a href="#local-6989586621679626753"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; p
forall a. HasCallStack =&gt; [Char] -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;panic! integral&quot;</span></span><span>
</span><span id="line-333"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-pragma hs-type">integral</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span class="hs-comment">-- | Accepts negative (starting with @-@) and positive (without sign) integral</span><span>
</span><span id="line-336"></span><span class="hs-comment">-- numbers.</span><span>
</span><span id="line-337"></span><span class="hs-comment">-- </span><span>
</span><span id="line-338"></span><span class="hs-comment">-- @since 3.4.0.0</span><span>
</span><span id="line-339"></span><span id="local-6989586621679626737"><span id="local-6989586621679626738"><span class="annot"><a href="Distribution.Compat.CharParsing.html#signedIntegral"><span class="hs-identifier hs-type">signedIntegral</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679626738"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679626737"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679626738"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679626737"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-340"></span><span id="signedIntegral"><span class="annot"><span class="annottext">signedIntegral :: forall (m :: * -&gt; *) a. (CharParsing m, Integral a) =&gt; m a
</span><a href="Distribution.Compat.CharParsing.html#signedIntegral"><span class="hs-identifier hs-var hs-var">signedIntegral</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#negate"><span class="hs-identifier hs-var">negate</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; a) -&gt; m Char -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a) -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
forall (m :: * -&gt; *) a. (CharParsing m, Integral a) =&gt; m a
</span><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-identifier hs-var">integral</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
forall (m :: * -&gt; *) a. (CharParsing m, Integral a) =&gt; m a
</span><a href="Distribution.Compat.CharParsing.html#integral"><span class="hs-identifier hs-var">integral</span></a></span><span>
</span><span id="line-341"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#signedIntegral"><span class="hs-pragma hs-type">signedIntegral</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-342"></span><span>
</span><span id="line-343"></span><span class="hs-comment">-- | Greedily munch characters while predicate holds.</span><span>
</span><span id="line-344"></span><span class="hs-comment">-- Require at least one character.</span><span>
</span><span id="line-345"></span><span id="local-6989586621679627304"><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-type">munch1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679627304"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679627304"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span></span><span>
</span><span id="line-346"></span><span id="munch1"><span class="annot"><span class="annottext">munch1 :: forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-var hs-var">munch1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m [Char]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier hs-var">some</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; m [Char])
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-347"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-pragma hs-type">munch1</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-348"></span><span>
</span><span id="line-349"></span><span class="hs-comment">-- | Greedely munch characters while predicate holds.</span><span>
</span><span id="line-350"></span><span class="hs-comment">-- Always succeeds.</span><span>
</span><span id="line-351"></span><span id="local-6989586621679626713"><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch"><span class="hs-identifier hs-type">munch</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679626713"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679626713"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span></span><span>
</span><span id="line-352"></span><span id="munch"><span class="annot"><span class="annottext">munch :: forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m [Char]
</span><a href="Distribution.Compat.CharParsing.html#munch"><span class="hs-identifier hs-var hs-var">munch</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m [Char]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="annot"><span class="annottext">(m Char -&gt; m [Char])
-&gt; ((Char -&gt; Bool) -&gt; m Char) -&gt; (Char -&gt; Bool) -&gt; m [Char]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span>
</span><span id="line-353"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#munch"><span class="hs-pragma hs-type">munch</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-354"></span><span>
</span><span id="line-355"></span><span id="local-6989586621679626706"><span class="annot"><a href="Distribution.Compat.CharParsing.html#skipSpaces1"><span class="hs-identifier hs-type">skipSpaces1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679626706"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679626706"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-356"></span><span id="skipSpaces1"><span class="annot"><span class="annottext">skipSpaces1 :: forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#skipSpaces1"><span class="hs-identifier hs-var hs-var">skipSpaces1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-var">skipSome</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#space"><span class="hs-identifier hs-var">space</span></a></span><span>
</span><span id="line-357"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#skipSpaces1"><span class="hs-pragma hs-type">skipSpaces1</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-358"></span></pre></body></html>